package com.xbfinance.manager.pojo.po;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class P2pProjectExample {
    protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

    public P2pProjectExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andIdIsNull() {
            addCriterion("id is null");
            return (Criteria) this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion("id is not null");
            return (Criteria) this;
        }

        public Criteria andIdEqualTo(Integer value) {
            addCriterion("id =", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotEqualTo(Integer value) {
            addCriterion("id <>", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThan(Integer value) {
            addCriterion("id >", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("id >=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThan(Integer value) {
            addCriterion("id <", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThanOrEqualTo(Integer value) {
            addCriterion("id <=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdIn(List<Integer> values) {
            addCriterion("id in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotIn(List<Integer> values) {
            addCriterion("id not in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdBetween(Integer value1, Integer value2) {
            addCriterion("id between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotBetween(Integer value1, Integer value2) {
            addCriterion("id not between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andProidIsNull() {
            addCriterion("proid is null");
            return (Criteria) this;
        }

        public Criteria andProidIsNotNull() {
            addCriterion("proid is not null");
            return (Criteria) this;
        }

        public Criteria andProidEqualTo(Long value) {
            addCriterion("proid =", value, "proid");
            return (Criteria) this;
        }

        public Criteria andProidNotEqualTo(Long value) {
            addCriterion("proid <>", value, "proid");
            return (Criteria) this;
        }

        public Criteria andProidGreaterThan(Long value) {
            addCriterion("proid >", value, "proid");
            return (Criteria) this;
        }

        public Criteria andProidGreaterThanOrEqualTo(Long value) {
            addCriterion("proid >=", value, "proid");
            return (Criteria) this;
        }

        public Criteria andProidLessThan(Long value) {
            addCriterion("proid <", value, "proid");
            return (Criteria) this;
        }

        public Criteria andProidLessThanOrEqualTo(Long value) {
            addCriterion("proid <=", value, "proid");
            return (Criteria) this;
        }

        public Criteria andProidIn(List<Long> values) {
            addCriterion("proid in", values, "proid");
            return (Criteria) this;
        }

        public Criteria andProidNotIn(List<Long> values) {
            addCriterion("proid not in", values, "proid");
            return (Criteria) this;
        }

        public Criteria andProidBetween(Long value1, Long value2) {
            addCriterion("proid between", value1, value2, "proid");
            return (Criteria) this;
        }

        public Criteria andProidNotBetween(Long value1, Long value2) {
            addCriterion("proid not between", value1, value2, "proid");
            return (Criteria) this;
        }

        public Criteria andUidIsNull() {
            addCriterion("uid is null");
            return (Criteria) this;
        }

        public Criteria andUidIsNotNull() {
            addCriterion("uid is not null");
            return (Criteria) this;
        }

        public Criteria andUidEqualTo(Long value) {
            addCriterion("uid =", value, "uid");
            return (Criteria) this;
        }

        public Criteria andUidNotEqualTo(Long value) {
            addCriterion("uid <>", value, "uid");
            return (Criteria) this;
        }

        public Criteria andUidGreaterThan(Long value) {
            addCriterion("uid >", value, "uid");
            return (Criteria) this;
        }

        public Criteria andUidGreaterThanOrEqualTo(Long value) {
            addCriterion("uid >=", value, "uid");
            return (Criteria) this;
        }

        public Criteria andUidLessThan(Long value) {
            addCriterion("uid <", value, "uid");
            return (Criteria) this;
        }

        public Criteria andUidLessThanOrEqualTo(Long value) {
            addCriterion("uid <=", value, "uid");
            return (Criteria) this;
        }

        public Criteria andUidIn(List<Long> values) {
            addCriterion("uid in", values, "uid");
            return (Criteria) this;
        }

        public Criteria andUidNotIn(List<Long> values) {
            addCriterion("uid not in", values, "uid");
            return (Criteria) this;
        }

        public Criteria andUidBetween(Long value1, Long value2) {
            addCriterion("uid between", value1, value2, "uid");
            return (Criteria) this;
        }

        public Criteria andUidNotBetween(Long value1, Long value2) {
            addCriterion("uid not between", value1, value2, "uid");
            return (Criteria) this;
        }

        public Criteria andPronameIsNull() {
            addCriterion("proname is null");
            return (Criteria) this;
        }

        public Criteria andPronameIsNotNull() {
            addCriterion("proname is not null");
            return (Criteria) this;
        }

        public Criteria andPronameEqualTo(String value) {
            addCriterion("proname =", value, "proname");
            return (Criteria) this;
        }

        public Criteria andPronameNotEqualTo(String value) {
            addCriterion("proname <>", value, "proname");
            return (Criteria) this;
        }

        public Criteria andPronameGreaterThan(String value) {
            addCriterion("proname >", value, "proname");
            return (Criteria) this;
        }

        public Criteria andPronameGreaterThanOrEqualTo(String value) {
            addCriterion("proname >=", value, "proname");
            return (Criteria) this;
        }

        public Criteria andPronameLessThan(String value) {
            addCriterion("proname <", value, "proname");
            return (Criteria) this;
        }

        public Criteria andPronameLessThanOrEqualTo(String value) {
            addCriterion("proname <=", value, "proname");
            return (Criteria) this;
        }

        public Criteria andPronameLike(String value) {
            addCriterion("proname like", value, "proname");
            return (Criteria) this;
        }

        public Criteria andPronameNotLike(String value) {
            addCriterion("proname not like", value, "proname");
            return (Criteria) this;
        }

        public Criteria andPronameIn(List<String> values) {
            addCriterion("proname in", values, "proname");
            return (Criteria) this;
        }

        public Criteria andPronameNotIn(List<String> values) {
            addCriterion("proname not in", values, "proname");
            return (Criteria) this;
        }

        public Criteria andPronameBetween(String value1, String value2) {
            addCriterion("proname between", value1, value2, "proname");
            return (Criteria) this;
        }

        public Criteria andPronameNotBetween(String value1, String value2) {
            addCriterion("proname not between", value1, value2, "proname");
            return (Criteria) this;
        }

        public Criteria andProaccountIsNull() {
            addCriterion("proaccount is null");
            return (Criteria) this;
        }

        public Criteria andProaccountIsNotNull() {
            addCriterion("proaccount is not null");
            return (Criteria) this;
        }

        public Criteria andProaccountEqualTo(Double value) {
            addCriterion("proaccount =", value, "proaccount");
            return (Criteria) this;
        }

        public Criteria andProaccountNotEqualTo(Double value) {
            addCriterion("proaccount <>", value, "proaccount");
            return (Criteria) this;
        }

        public Criteria andProaccountGreaterThan(Double value) {
            addCriterion("proaccount >", value, "proaccount");
            return (Criteria) this;
        }

        public Criteria andProaccountGreaterThanOrEqualTo(Double value) {
            addCriterion("proaccount >=", value, "proaccount");
            return (Criteria) this;
        }

        public Criteria andProaccountLessThan(Double value) {
            addCriterion("proaccount <", value, "proaccount");
            return (Criteria) this;
        }

        public Criteria andProaccountLessThanOrEqualTo(Double value) {
            addCriterion("proaccount <=", value, "proaccount");
            return (Criteria) this;
        }

        public Criteria andProaccountIn(List<Double> values) {
            addCriterion("proaccount in", values, "proaccount");
            return (Criteria) this;
        }

        public Criteria andProaccountNotIn(List<Double> values) {
            addCriterion("proaccount not in", values, "proaccount");
            return (Criteria) this;
        }

        public Criteria andProaccountBetween(Double value1, Double value2) {
            addCriterion("proaccount between", value1, value2, "proaccount");
            return (Criteria) this;
        }

        public Criteria andProaccountNotBetween(Double value1, Double value2) {
            addCriterion("proaccount not between", value1, value2, "proaccount");
            return (Criteria) this;
        }

        public Criteria andProaccountyesIsNull() {
            addCriterion("proaccountyes is null");
            return (Criteria) this;
        }

        public Criteria andProaccountyesIsNotNull() {
            addCriterion("proaccountyes is not null");
            return (Criteria) this;
        }

        public Criteria andProaccountyesEqualTo(Double value) {
            addCriterion("proaccountyes =", value, "proaccountyes");
            return (Criteria) this;
        }

        public Criteria andProaccountyesNotEqualTo(Double value) {
            addCriterion("proaccountyes <>", value, "proaccountyes");
            return (Criteria) this;
        }

        public Criteria andProaccountyesGreaterThan(Double value) {
            addCriterion("proaccountyes >", value, "proaccountyes");
            return (Criteria) this;
        }

        public Criteria andProaccountyesGreaterThanOrEqualTo(Double value) {
            addCriterion("proaccountyes >=", value, "proaccountyes");
            return (Criteria) this;
        }

        public Criteria andProaccountyesLessThan(Double value) {
            addCriterion("proaccountyes <", value, "proaccountyes");
            return (Criteria) this;
        }

        public Criteria andProaccountyesLessThanOrEqualTo(Double value) {
            addCriterion("proaccountyes <=", value, "proaccountyes");
            return (Criteria) this;
        }

        public Criteria andProaccountyesIn(List<Double> values) {
            addCriterion("proaccountyes in", values, "proaccountyes");
            return (Criteria) this;
        }

        public Criteria andProaccountyesNotIn(List<Double> values) {
            addCriterion("proaccountyes not in", values, "proaccountyes");
            return (Criteria) this;
        }

        public Criteria andProaccountyesBetween(Double value1, Double value2) {
            addCriterion("proaccountyes between", value1, value2, "proaccountyes");
            return (Criteria) this;
        }

        public Criteria andProaccountyesNotBetween(Double value1, Double value2) {
            addCriterion("proaccountyes not between", value1, value2, "proaccountyes");
            return (Criteria) this;
        }

        public Criteria andProtimelimitIsNull() {
            addCriterion("protimelimit is null");
            return (Criteria) this;
        }

        public Criteria andProtimelimitIsNotNull() {
            addCriterion("protimelimit is not null");
            return (Criteria) this;
        }

        public Criteria andProtimelimitEqualTo(Integer value) {
            addCriterion("protimelimit =", value, "protimelimit");
            return (Criteria) this;
        }

        public Criteria andProtimelimitNotEqualTo(Integer value) {
            addCriterion("protimelimit <>", value, "protimelimit");
            return (Criteria) this;
        }

        public Criteria andProtimelimitGreaterThan(Integer value) {
            addCriterion("protimelimit >", value, "protimelimit");
            return (Criteria) this;
        }

        public Criteria andProtimelimitGreaterThanOrEqualTo(Integer value) {
            addCriterion("protimelimit >=", value, "protimelimit");
            return (Criteria) this;
        }

        public Criteria andProtimelimitLessThan(Integer value) {
            addCriterion("protimelimit <", value, "protimelimit");
            return (Criteria) this;
        }

        public Criteria andProtimelimitLessThanOrEqualTo(Integer value) {
            addCriterion("protimelimit <=", value, "protimelimit");
            return (Criteria) this;
        }

        public Criteria andProtimelimitIn(List<Integer> values) {
            addCriterion("protimelimit in", values, "protimelimit");
            return (Criteria) this;
        }

        public Criteria andProtimelimitNotIn(List<Integer> values) {
            addCriterion("protimelimit not in", values, "protimelimit");
            return (Criteria) this;
        }

        public Criteria andProtimelimitBetween(Integer value1, Integer value2) {
            addCriterion("protimelimit between", value1, value2, "protimelimit");
            return (Criteria) this;
        }

        public Criteria andProtimelimitNotBetween(Integer value1, Integer value2) {
            addCriterion("protimelimit not between", value1, value2, "protimelimit");
            return (Criteria) this;
        }

        public Criteria andProtimeuintIsNull() {
            addCriterion("protimeuint is null");
            return (Criteria) this;
        }

        public Criteria andProtimeuintIsNotNull() {
            addCriterion("protimeuint is not null");
            return (Criteria) this;
        }

        public Criteria andProtimeuintEqualTo(Byte value) {
            addCriterion("protimeuint =", value, "protimeuint");
            return (Criteria) this;
        }

        public Criteria andProtimeuintNotEqualTo(Byte value) {
            addCriterion("protimeuint <>", value, "protimeuint");
            return (Criteria) this;
        }

        public Criteria andProtimeuintGreaterThan(Byte value) {
            addCriterion("protimeuint >", value, "protimeuint");
            return (Criteria) this;
        }

        public Criteria andProtimeuintGreaterThanOrEqualTo(Byte value) {
            addCriterion("protimeuint >=", value, "protimeuint");
            return (Criteria) this;
        }

        public Criteria andProtimeuintLessThan(Byte value) {
            addCriterion("protimeuint <", value, "protimeuint");
            return (Criteria) this;
        }

        public Criteria andProtimeuintLessThanOrEqualTo(Byte value) {
            addCriterion("protimeuint <=", value, "protimeuint");
            return (Criteria) this;
        }

        public Criteria andProtimeuintIn(List<Byte> values) {
            addCriterion("protimeuint in", values, "protimeuint");
            return (Criteria) this;
        }

        public Criteria andProtimeuintNotIn(List<Byte> values) {
            addCriterion("protimeuint not in", values, "protimeuint");
            return (Criteria) this;
        }

        public Criteria andProtimeuintBetween(Byte value1, Byte value2) {
            addCriterion("protimeuint between", value1, value2, "protimeuint");
            return (Criteria) this;
        }

        public Criteria andProtimeuintNotBetween(Byte value1, Byte value2) {
            addCriterion("protimeuint not between", value1, value2, "protimeuint");
            return (Criteria) this;
        }

        public Criteria andProvalidtimeIsNull() {
            addCriterion("provalidtime is null");
            return (Criteria) this;
        }

        public Criteria andProvalidtimeIsNotNull() {
            addCriterion("provalidtime is not null");
            return (Criteria) this;
        }

        public Criteria andProvalidtimeEqualTo(Date value) {
            addCriterion("provalidtime =", value, "provalidtime");
            return (Criteria) this;
        }

        public Criteria andProvalidtimeNotEqualTo(Date value) {
            addCriterion("provalidtime <>", value, "provalidtime");
            return (Criteria) this;
        }

        public Criteria andProvalidtimeGreaterThan(Date value) {
            addCriterion("provalidtime >", value, "provalidtime");
            return (Criteria) this;
        }

        public Criteria andProvalidtimeGreaterThanOrEqualTo(Date value) {
            addCriterion("provalidtime >=", value, "provalidtime");
            return (Criteria) this;
        }

        public Criteria andProvalidtimeLessThan(Date value) {
            addCriterion("provalidtime <", value, "provalidtime");
            return (Criteria) this;
        }

        public Criteria andProvalidtimeLessThanOrEqualTo(Date value) {
            addCriterion("provalidtime <=", value, "provalidtime");
            return (Criteria) this;
        }

        public Criteria andProvalidtimeIn(List<Date> values) {
            addCriterion("provalidtime in", values, "provalidtime");
            return (Criteria) this;
        }

        public Criteria andProvalidtimeNotIn(List<Date> values) {
            addCriterion("provalidtime not in", values, "provalidtime");
            return (Criteria) this;
        }

        public Criteria andProvalidtimeBetween(Date value1, Date value2) {
            addCriterion("provalidtime between", value1, value2, "provalidtime");
            return (Criteria) this;
        }

        public Criteria andProvalidtimeNotBetween(Date value1, Date value2) {
            addCriterion("provalidtime not between", value1, value2, "provalidtime");
            return (Criteria) this;
        }

        public Criteria andProaprIsNull() {
            addCriterion("proapr is null");
            return (Criteria) this;
        }

        public Criteria andProaprIsNotNull() {
            addCriterion("proapr is not null");
            return (Criteria) this;
        }

        public Criteria andProaprEqualTo(Double value) {
            addCriterion("proapr =", value, "proapr");
            return (Criteria) this;
        }

        public Criteria andProaprNotEqualTo(Double value) {
            addCriterion("proapr <>", value, "proapr");
            return (Criteria) this;
        }

        public Criteria andProaprGreaterThan(Double value) {
            addCriterion("proapr >", value, "proapr");
            return (Criteria) this;
        }

        public Criteria andProaprGreaterThanOrEqualTo(Double value) {
            addCriterion("proapr >=", value, "proapr");
            return (Criteria) this;
        }

        public Criteria andProaprLessThan(Double value) {
            addCriterion("proapr <", value, "proapr");
            return (Criteria) this;
        }

        public Criteria andProaprLessThanOrEqualTo(Double value) {
            addCriterion("proapr <=", value, "proapr");
            return (Criteria) this;
        }

        public Criteria andProaprIn(List<Double> values) {
            addCriterion("proapr in", values, "proapr");
            return (Criteria) this;
        }

        public Criteria andProaprNotIn(List<Double> values) {
            addCriterion("proapr not in", values, "proapr");
            return (Criteria) this;
        }

        public Criteria andProaprBetween(Double value1, Double value2) {
            addCriterion("proapr between", value1, value2, "proapr");
            return (Criteria) this;
        }

        public Criteria andProaprNotBetween(Double value1, Double value2) {
            addCriterion("proapr not between", value1, value2, "proapr");
            return (Criteria) this;
        }

        public Criteria andProstyleIsNull() {
            addCriterion("prostyle is null");
            return (Criteria) this;
        }

        public Criteria andProstyleIsNotNull() {
            addCriterion("prostyle is not null");
            return (Criteria) this;
        }

        public Criteria andProstyleEqualTo(Byte value) {
            addCriterion("prostyle =", value, "prostyle");
            return (Criteria) this;
        }

        public Criteria andProstyleNotEqualTo(Byte value) {
            addCriterion("prostyle <>", value, "prostyle");
            return (Criteria) this;
        }

        public Criteria andProstyleGreaterThan(Byte value) {
            addCriterion("prostyle >", value, "prostyle");
            return (Criteria) this;
        }

        public Criteria andProstyleGreaterThanOrEqualTo(Byte value) {
            addCriterion("prostyle >=", value, "prostyle");
            return (Criteria) this;
        }

        public Criteria andProstyleLessThan(Byte value) {
            addCriterion("prostyle <", value, "prostyle");
            return (Criteria) this;
        }

        public Criteria andProstyleLessThanOrEqualTo(Byte value) {
            addCriterion("prostyle <=", value, "prostyle");
            return (Criteria) this;
        }

        public Criteria andProstyleIn(List<Byte> values) {
            addCriterion("prostyle in", values, "prostyle");
            return (Criteria) this;
        }

        public Criteria andProstyleNotIn(List<Byte> values) {
            addCriterion("prostyle not in", values, "prostyle");
            return (Criteria) this;
        }

        public Criteria andProstyleBetween(Byte value1, Byte value2) {
            addCriterion("prostyle between", value1, value2, "prostyle");
            return (Criteria) this;
        }

        public Criteria andProstyleNotBetween(Byte value1, Byte value2) {
            addCriterion("prostyle not between", value1, value2, "prostyle");
            return (Criteria) this;
        }

        public Criteria andProstatusIsNull() {
            addCriterion("prostatus is null");
            return (Criteria) this;
        }

        public Criteria andProstatusIsNotNull() {
            addCriterion("prostatus is not null");
            return (Criteria) this;
        }

        public Criteria andProstatusEqualTo(Byte value) {
            addCriterion("prostatus =", value, "prostatus");
            return (Criteria) this;
        }

        public Criteria andProstatusNotEqualTo(Byte value) {
            addCriterion("prostatus <>", value, "prostatus");
            return (Criteria) this;
        }

        public Criteria andProstatusGreaterThan(Byte value) {
            addCriterion("prostatus >", value, "prostatus");
            return (Criteria) this;
        }

        public Criteria andProstatusGreaterThanOrEqualTo(Byte value) {
            addCriterion("prostatus >=", value, "prostatus");
            return (Criteria) this;
        }

        public Criteria andProstatusLessThan(Byte value) {
            addCriterion("prostatus <", value, "prostatus");
            return (Criteria) this;
        }

        public Criteria andProstatusLessThanOrEqualTo(Byte value) {
            addCriterion("prostatus <=", value, "prostatus");
            return (Criteria) this;
        }

        public Criteria andProstatusIn(List<Byte> values) {
            addCriterion("prostatus in", values, "prostatus");
            return (Criteria) this;
        }

        public Criteria andProstatusNotIn(List<Byte> values) {
            addCriterion("prostatus not in", values, "prostatus");
            return (Criteria) this;
        }

        public Criteria andProstatusBetween(Byte value1, Byte value2) {
            addCriterion("prostatus between", value1, value2, "prostatus");
            return (Criteria) this;
        }

        public Criteria andProstatusNotBetween(Byte value1, Byte value2) {
            addCriterion("prostatus not between", value1, value2, "prostatus");
            return (Criteria) this;
        }

        public Criteria andProverifyuserIsNull() {
            addCriterion("proverifyuser is null");
            return (Criteria) this;
        }

        public Criteria andProverifyuserIsNotNull() {
            addCriterion("proverifyuser is not null");
            return (Criteria) this;
        }

        public Criteria andProverifyuserEqualTo(Integer value) {
            addCriterion("proverifyuser =", value, "proverifyuser");
            return (Criteria) this;
        }

        public Criteria andProverifyuserNotEqualTo(Integer value) {
            addCriterion("proverifyuser <>", value, "proverifyuser");
            return (Criteria) this;
        }

        public Criteria andProverifyuserGreaterThan(Integer value) {
            addCriterion("proverifyuser >", value, "proverifyuser");
            return (Criteria) this;
        }

        public Criteria andProverifyuserGreaterThanOrEqualTo(Integer value) {
            addCriterion("proverifyuser >=", value, "proverifyuser");
            return (Criteria) this;
        }

        public Criteria andProverifyuserLessThan(Integer value) {
            addCriterion("proverifyuser <", value, "proverifyuser");
            return (Criteria) this;
        }

        public Criteria andProverifyuserLessThanOrEqualTo(Integer value) {
            addCriterion("proverifyuser <=", value, "proverifyuser");
            return (Criteria) this;
        }

        public Criteria andProverifyuserIn(List<Integer> values) {
            addCriterion("proverifyuser in", values, "proverifyuser");
            return (Criteria) this;
        }

        public Criteria andProverifyuserNotIn(List<Integer> values) {
            addCriterion("proverifyuser not in", values, "proverifyuser");
            return (Criteria) this;
        }

        public Criteria andProverifyuserBetween(Integer value1, Integer value2) {
            addCriterion("proverifyuser between", value1, value2, "proverifyuser");
            return (Criteria) this;
        }

        public Criteria andProverifyuserNotBetween(Integer value1, Integer value2) {
            addCriterion("proverifyuser not between", value1, value2, "proverifyuser");
            return (Criteria) this;
        }

        public Criteria andProverifytimeIsNull() {
            addCriterion("proverifytime is null");
            return (Criteria) this;
        }

        public Criteria andProverifytimeIsNotNull() {
            addCriterion("proverifytime is not null");
            return (Criteria) this;
        }

        public Criteria andProverifytimeEqualTo(Date value) {
            addCriterion("proverifytime =", value, "proverifytime");
            return (Criteria) this;
        }

        public Criteria andProverifytimeNotEqualTo(Date value) {
            addCriterion("proverifytime <>", value, "proverifytime");
            return (Criteria) this;
        }

        public Criteria andProverifytimeGreaterThan(Date value) {
            addCriterion("proverifytime >", value, "proverifytime");
            return (Criteria) this;
        }

        public Criteria andProverifytimeGreaterThanOrEqualTo(Date value) {
            addCriterion("proverifytime >=", value, "proverifytime");
            return (Criteria) this;
        }

        public Criteria andProverifytimeLessThan(Date value) {
            addCriterion("proverifytime <", value, "proverifytime");
            return (Criteria) this;
        }

        public Criteria andProverifytimeLessThanOrEqualTo(Date value) {
            addCriterion("proverifytime <=", value, "proverifytime");
            return (Criteria) this;
        }

        public Criteria andProverifytimeIn(List<Date> values) {
            addCriterion("proverifytime in", values, "proverifytime");
            return (Criteria) this;
        }

        public Criteria andProverifytimeNotIn(List<Date> values) {
            addCriterion("proverifytime not in", values, "proverifytime");
            return (Criteria) this;
        }

        public Criteria andProverifytimeBetween(Date value1, Date value2) {
            addCriterion("proverifytime between", value1, value2, "proverifytime");
            return (Criteria) this;
        }

        public Criteria andProverifytimeNotBetween(Date value1, Date value2) {
            addCriterion("proverifytime not between", value1, value2, "proverifytime");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkIsNull() {
            addCriterion("proverifyremark is null");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkIsNotNull() {
            addCriterion("proverifyremark is not null");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkEqualTo(String value) {
            addCriterion("proverifyremark =", value, "proverifyremark");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkNotEqualTo(String value) {
            addCriterion("proverifyremark <>", value, "proverifyremark");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkGreaterThan(String value) {
            addCriterion("proverifyremark >", value, "proverifyremark");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkGreaterThanOrEqualTo(String value) {
            addCriterion("proverifyremark >=", value, "proverifyremark");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkLessThan(String value) {
            addCriterion("proverifyremark <", value, "proverifyremark");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkLessThanOrEqualTo(String value) {
            addCriterion("proverifyremark <=", value, "proverifyremark");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkLike(String value) {
            addCriterion("proverifyremark like", value, "proverifyremark");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkNotLike(String value) {
            addCriterion("proverifyremark not like", value, "proverifyremark");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkIn(List<String> values) {
            addCriterion("proverifyremark in", values, "proverifyremark");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkNotIn(List<String> values) {
            addCriterion("proverifyremark not in", values, "proverifyremark");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkBetween(String value1, String value2) {
            addCriterion("proverifyremark between", value1, value2, "proverifyremark");
            return (Criteria) this;
        }

        public Criteria andProverifyremarkNotBetween(String value1, String value2) {
            addCriterion("proverifyremark not between", value1, value2, "proverifyremark");
            return (Criteria) this;
        }

        public Criteria andProfullverifyuserIsNull() {
            addCriterion("profullverifyuser is null");
            return (Criteria) this;
        }

        public Criteria andProfullverifyuserIsNotNull() {
            addCriterion("profullverifyuser is not null");
            return (Criteria) this;
        }

        public Criteria andProfullverifyuserEqualTo(Integer value) {
            addCriterion("profullverifyuser =", value, "profullverifyuser");
            return (Criteria) this;
        }

        public Criteria andProfullverifyuserNotEqualTo(Integer value) {
            addCriterion("profullverifyuser <>", value, "profullverifyuser");
            return (Criteria) this;
        }

        public Criteria andProfullverifyuserGreaterThan(Integer value) {
            addCriterion("profullverifyuser >", value, "profullverifyuser");
            return (Criteria) this;
        }

        public Criteria andProfullverifyuserGreaterThanOrEqualTo(Integer value) {
            addCriterion("profullverifyuser >=", value, "profullverifyuser");
            return (Criteria) this;
        }

        public Criteria andProfullverifyuserLessThan(Integer value) {
            addCriterion("profullverifyuser <", value, "profullverifyuser");
            return (Criteria) this;
        }

        public Criteria andProfullverifyuserLessThanOrEqualTo(Integer value) {
            addCriterion("profullverifyuser <=", value, "profullverifyuser");
            return (Criteria) this;
        }

        public Criteria andProfullverifyuserIn(List<Integer> values) {
            addCriterion("profullverifyuser in", values, "profullverifyuser");
            return (Criteria) this;
        }

        public Criteria andProfullverifyuserNotIn(List<Integer> values) {
            addCriterion("profullverifyuser not in", values, "profullverifyuser");
            return (Criteria) this;
        }

        public Criteria andProfullverifyuserBetween(Integer value1, Integer value2) {
            addCriterion("profullverifyuser between", value1, value2, "profullverifyuser");
            return (Criteria) this;
        }

        public Criteria andProfullverifyuserNotBetween(Integer value1, Integer value2) {
            addCriterion("profullverifyuser not between", value1, value2, "profullverifyuser");
            return (Criteria) this;
        }

        public Criteria andProfullverifytimeIsNull() {
            addCriterion("profullverifytime is null");
            return (Criteria) this;
        }

        public Criteria andProfullverifytimeIsNotNull() {
            addCriterion("profullverifytime is not null");
            return (Criteria) this;
        }

        public Criteria andProfullverifytimeEqualTo(Date value) {
            addCriterion("profullverifytime =", value, "profullverifytime");
            return (Criteria) this;
        }

        public Criteria andProfullverifytimeNotEqualTo(Date value) {
            addCriterion("profullverifytime <>", value, "profullverifytime");
            return (Criteria) this;
        }

        public Criteria andProfullverifytimeGreaterThan(Date value) {
            addCriterion("profullverifytime >", value, "profullverifytime");
            return (Criteria) this;
        }

        public Criteria andProfullverifytimeGreaterThanOrEqualTo(Date value) {
            addCriterion("profullverifytime >=", value, "profullverifytime");
            return (Criteria) this;
        }

        public Criteria andProfullverifytimeLessThan(Date value) {
            addCriterion("profullverifytime <", value, "profullverifytime");
            return (Criteria) this;
        }

        public Criteria andProfullverifytimeLessThanOrEqualTo(Date value) {
            addCriterion("profullverifytime <=", value, "profullverifytime");
            return (Criteria) this;
        }

        public Criteria andProfullverifytimeIn(List<Date> values) {
            addCriterion("profullverifytime in", values, "profullverifytime");
            return (Criteria) this;
        }

        public Criteria andProfullverifytimeNotIn(List<Date> values) {
            addCriterion("profullverifytime not in", values, "profullverifytime");
            return (Criteria) this;
        }

        public Criteria andProfullverifytimeBetween(Date value1, Date value2) {
            addCriterion("profullverifytime between", value1, value2, "profullverifytime");
            return (Criteria) this;
        }

        public Criteria andProfullverifytimeNotBetween(Date value1, Date value2) {
            addCriterion("profullverifytime not between", value1, value2, "profullverifytime");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkIsNull() {
            addCriterion("profullverifyremark is null");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkIsNotNull() {
            addCriterion("profullverifyremark is not null");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkEqualTo(String value) {
            addCriterion("profullverifyremark =", value, "profullverifyremark");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkNotEqualTo(String value) {
            addCriterion("profullverifyremark <>", value, "profullverifyremark");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkGreaterThan(String value) {
            addCriterion("profullverifyremark >", value, "profullverifyremark");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkGreaterThanOrEqualTo(String value) {
            addCriterion("profullverifyremark >=", value, "profullverifyremark");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkLessThan(String value) {
            addCriterion("profullverifyremark <", value, "profullverifyremark");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkLessThanOrEqualTo(String value) {
            addCriterion("profullverifyremark <=", value, "profullverifyremark");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkLike(String value) {
            addCriterion("profullverifyremark like", value, "profullverifyremark");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkNotLike(String value) {
            addCriterion("profullverifyremark not like", value, "profullverifyremark");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkIn(List<String> values) {
            addCriterion("profullverifyremark in", values, "profullverifyremark");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkNotIn(List<String> values) {
            addCriterion("profullverifyremark not in", values, "profullverifyremark");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkBetween(String value1, String value2) {
            addCriterion("profullverifyremark between", value1, value2, "profullverifyremark");
            return (Criteria) this;
        }

        public Criteria andProfullverifyremarkNotBetween(String value1, String value2) {
            addCriterion("profullverifyremark not between", value1, value2, "profullverifyremark");
            return (Criteria) this;
        }

        public Criteria andProtypeIsNull() {
            addCriterion("protype is null");
            return (Criteria) this;
        }

        public Criteria andProtypeIsNotNull() {
            addCriterion("protype is not null");
            return (Criteria) this;
        }

        public Criteria andProtypeEqualTo(Byte value) {
            addCriterion("protype =", value, "protype");
            return (Criteria) this;
        }

        public Criteria andProtypeNotEqualTo(Byte value) {
            addCriterion("protype <>", value, "protype");
            return (Criteria) this;
        }

        public Criteria andProtypeGreaterThan(Byte value) {
            addCriterion("protype >", value, "protype");
            return (Criteria) this;
        }

        public Criteria andProtypeGreaterThanOrEqualTo(Byte value) {
            addCriterion("protype >=", value, "protype");
            return (Criteria) this;
        }

        public Criteria andProtypeLessThan(Byte value) {
            addCriterion("protype <", value, "protype");
            return (Criteria) this;
        }

        public Criteria andProtypeLessThanOrEqualTo(Byte value) {
            addCriterion("protype <=", value, "protype");
            return (Criteria) this;
        }

        public Criteria andProtypeIn(List<Byte> values) {
            addCriterion("protype in", values, "protype");
            return (Criteria) this;
        }

        public Criteria andProtypeNotIn(List<Byte> values) {
            addCriterion("protype not in", values, "protype");
            return (Criteria) this;
        }

        public Criteria andProtypeBetween(Byte value1, Byte value2) {
            addCriterion("protype between", value1, value2, "protype");
            return (Criteria) this;
        }

        public Criteria andProtypeNotBetween(Byte value1, Byte value2) {
            addCriterion("protype not between", value1, value2, "protype");
            return (Criteria) this;
        }

        public Criteria andProdxbIsNull() {
            addCriterion("prodxb is null");
            return (Criteria) this;
        }

        public Criteria andProdxbIsNotNull() {
            addCriterion("prodxb is not null");
            return (Criteria) this;
        }

        public Criteria andProdxbEqualTo(String value) {
            addCriterion("prodxb =", value, "prodxb");
            return (Criteria) this;
        }

        public Criteria andProdxbNotEqualTo(String value) {
            addCriterion("prodxb <>", value, "prodxb");
            return (Criteria) this;
        }

        public Criteria andProdxbGreaterThan(String value) {
            addCriterion("prodxb >", value, "prodxb");
            return (Criteria) this;
        }

        public Criteria andProdxbGreaterThanOrEqualTo(String value) {
            addCriterion("prodxb >=", value, "prodxb");
            return (Criteria) this;
        }

        public Criteria andProdxbLessThan(String value) {
            addCriterion("prodxb <", value, "prodxb");
            return (Criteria) this;
        }

        public Criteria andProdxbLessThanOrEqualTo(String value) {
            addCriterion("prodxb <=", value, "prodxb");
            return (Criteria) this;
        }

        public Criteria andProdxbLike(String value) {
            addCriterion("prodxb like", value, "prodxb");
            return (Criteria) this;
        }

        public Criteria andProdxbNotLike(String value) {
            addCriterion("prodxb not like", value, "prodxb");
            return (Criteria) this;
        }

        public Criteria andProdxbIn(List<String> values) {
            addCriterion("prodxb in", values, "prodxb");
            return (Criteria) this;
        }

        public Criteria andProdxbNotIn(List<String> values) {
            addCriterion("prodxb not in", values, "prodxb");
            return (Criteria) this;
        }

        public Criteria andProdxbBetween(String value1, String value2) {
            addCriterion("prodxb between", value1, value2, "prodxb");
            return (Criteria) this;
        }

        public Criteria andProdxbNotBetween(String value1, String value2) {
            addCriterion("prodxb not between", value1, value2, "prodxb");
            return (Criteria) this;
        }

        public Criteria andProdescIsNull() {
            addCriterion("prodesc is null");
            return (Criteria) this;
        }

        public Criteria andProdescIsNotNull() {
            addCriterion("prodesc is not null");
            return (Criteria) this;
        }

        public Criteria andProdescEqualTo(String value) {
            addCriterion("prodesc =", value, "prodesc");
            return (Criteria) this;
        }

        public Criteria andProdescNotEqualTo(String value) {
            addCriterion("prodesc <>", value, "prodesc");
            return (Criteria) this;
        }

        public Criteria andProdescGreaterThan(String value) {
            addCriterion("prodesc >", value, "prodesc");
            return (Criteria) this;
        }

        public Criteria andProdescGreaterThanOrEqualTo(String value) {
            addCriterion("prodesc >=", value, "prodesc");
            return (Criteria) this;
        }

        public Criteria andProdescLessThan(String value) {
            addCriterion("prodesc <", value, "prodesc");
            return (Criteria) this;
        }

        public Criteria andProdescLessThanOrEqualTo(String value) {
            addCriterion("prodesc <=", value, "prodesc");
            return (Criteria) this;
        }

        public Criteria andProdescLike(String value) {
            addCriterion("prodesc like", value, "prodesc");
            return (Criteria) this;
        }

        public Criteria andProdescNotLike(String value) {
            addCriterion("prodesc not like", value, "prodesc");
            return (Criteria) this;
        }

        public Criteria andProdescIn(List<String> values) {
            addCriterion("prodesc in", values, "prodesc");
            return (Criteria) this;
        }

        public Criteria andProdescNotIn(List<String> values) {
            addCriterion("prodesc not in", values, "prodesc");
            return (Criteria) this;
        }

        public Criteria andProdescBetween(String value1, String value2) {
            addCriterion("prodesc between", value1, value2, "prodesc");
            return (Criteria) this;
        }

        public Criteria andProdescNotBetween(String value1, String value2) {
            addCriterion("prodesc not between", value1, value2, "prodesc");
            return (Criteria) this;
        }

        public Criteria andProawardtypeIsNull() {
            addCriterion("proawardtype is null");
            return (Criteria) this;
        }

        public Criteria andProawardtypeIsNotNull() {
            addCriterion("proawardtype is not null");
            return (Criteria) this;
        }

        public Criteria andProawardtypeEqualTo(Byte value) {
            addCriterion("proawardtype =", value, "proawardtype");
            return (Criteria) this;
        }

        public Criteria andProawardtypeNotEqualTo(Byte value) {
            addCriterion("proawardtype <>", value, "proawardtype");
            return (Criteria) this;
        }

        public Criteria andProawardtypeGreaterThan(Byte value) {
            addCriterion("proawardtype >", value, "proawardtype");
            return (Criteria) this;
        }

        public Criteria andProawardtypeGreaterThanOrEqualTo(Byte value) {
            addCriterion("proawardtype >=", value, "proawardtype");
            return (Criteria) this;
        }

        public Criteria andProawardtypeLessThan(Byte value) {
            addCriterion("proawardtype <", value, "proawardtype");
            return (Criteria) this;
        }

        public Criteria andProawardtypeLessThanOrEqualTo(Byte value) {
            addCriterion("proawardtype <=", value, "proawardtype");
            return (Criteria) this;
        }

        public Criteria andProawardtypeIn(List<Byte> values) {
            addCriterion("proawardtype in", values, "proawardtype");
            return (Criteria) this;
        }

        public Criteria andProawardtypeNotIn(List<Byte> values) {
            addCriterion("proawardtype not in", values, "proawardtype");
            return (Criteria) this;
        }

        public Criteria andProawardtypeBetween(Byte value1, Byte value2) {
            addCriterion("proawardtype between", value1, value2, "proawardtype");
            return (Criteria) this;
        }

        public Criteria andProawardtypeNotBetween(Byte value1, Byte value2) {
            addCriterion("proawardtype not between", value1, value2, "proawardtype");
            return (Criteria) this;
        }

        public Criteria andProawardIsNull() {
            addCriterion("proaward is null");
            return (Criteria) this;
        }

        public Criteria andProawardIsNotNull() {
            addCriterion("proaward is not null");
            return (Criteria) this;
        }

        public Criteria andProawardEqualTo(Double value) {
            addCriterion("proaward =", value, "proaward");
            return (Criteria) this;
        }

        public Criteria andProawardNotEqualTo(Double value) {
            addCriterion("proaward <>", value, "proaward");
            return (Criteria) this;
        }

        public Criteria andProawardGreaterThan(Double value) {
            addCriterion("proaward >", value, "proaward");
            return (Criteria) this;
        }

        public Criteria andProawardGreaterThanOrEqualTo(Double value) {
            addCriterion("proaward >=", value, "proaward");
            return (Criteria) this;
        }

        public Criteria andProawardLessThan(Double value) {
            addCriterion("proaward <", value, "proaward");
            return (Criteria) this;
        }

        public Criteria andProawardLessThanOrEqualTo(Double value) {
            addCriterion("proaward <=", value, "proaward");
            return (Criteria) this;
        }

        public Criteria andProawardIn(List<Double> values) {
            addCriterion("proaward in", values, "proaward");
            return (Criteria) this;
        }

        public Criteria andProawardNotIn(List<Double> values) {
            addCriterion("proaward not in", values, "proaward");
            return (Criteria) this;
        }

        public Criteria andProawardBetween(Double value1, Double value2) {
            addCriterion("proaward between", value1, value2, "proaward");
            return (Criteria) this;
        }

        public Criteria andProawardNotBetween(Double value1, Double value2) {
            addCriterion("proaward not between", value1, value2, "proaward");
            return (Criteria) this;
        }

        public Criteria andProlowaccountIsNull() {
            addCriterion("prolowaccount is null");
            return (Criteria) this;
        }

        public Criteria andProlowaccountIsNotNull() {
            addCriterion("prolowaccount is not null");
            return (Criteria) this;
        }

        public Criteria andProlowaccountEqualTo(Double value) {
            addCriterion("prolowaccount =", value, "prolowaccount");
            return (Criteria) this;
        }

        public Criteria andProlowaccountNotEqualTo(Double value) {
            addCriterion("prolowaccount <>", value, "prolowaccount");
            return (Criteria) this;
        }

        public Criteria andProlowaccountGreaterThan(Double value) {
            addCriterion("prolowaccount >", value, "prolowaccount");
            return (Criteria) this;
        }

        public Criteria andProlowaccountGreaterThanOrEqualTo(Double value) {
            addCriterion("prolowaccount >=", value, "prolowaccount");
            return (Criteria) this;
        }

        public Criteria andProlowaccountLessThan(Double value) {
            addCriterion("prolowaccount <", value, "prolowaccount");
            return (Criteria) this;
        }

        public Criteria andProlowaccountLessThanOrEqualTo(Double value) {
            addCriterion("prolowaccount <=", value, "prolowaccount");
            return (Criteria) this;
        }

        public Criteria andProlowaccountIn(List<Double> values) {
            addCriterion("prolowaccount in", values, "prolowaccount");
            return (Criteria) this;
        }

        public Criteria andProlowaccountNotIn(List<Double> values) {
            addCriterion("prolowaccount not in", values, "prolowaccount");
            return (Criteria) this;
        }

        public Criteria andProlowaccountBetween(Double value1, Double value2) {
            addCriterion("prolowaccount between", value1, value2, "prolowaccount");
            return (Criteria) this;
        }

        public Criteria andProlowaccountNotBetween(Double value1, Double value2) {
            addCriterion("prolowaccount not between", value1, value2, "prolowaccount");
            return (Criteria) this;
        }

        public Criteria andPromostaccountIsNull() {
            addCriterion("promostaccount is null");
            return (Criteria) this;
        }

        public Criteria andPromostaccountIsNotNull() {
            addCriterion("promostaccount is not null");
            return (Criteria) this;
        }

        public Criteria andPromostaccountEqualTo(Double value) {
            addCriterion("promostaccount =", value, "promostaccount");
            return (Criteria) this;
        }

        public Criteria andPromostaccountNotEqualTo(Double value) {
            addCriterion("promostaccount <>", value, "promostaccount");
            return (Criteria) this;
        }

        public Criteria andPromostaccountGreaterThan(Double value) {
            addCriterion("promostaccount >", value, "promostaccount");
            return (Criteria) this;
        }

        public Criteria andPromostaccountGreaterThanOrEqualTo(Double value) {
            addCriterion("promostaccount >=", value, "promostaccount");
            return (Criteria) this;
        }

        public Criteria andPromostaccountLessThan(Double value) {
            addCriterion("promostaccount <", value, "promostaccount");
            return (Criteria) this;
        }

        public Criteria andPromostaccountLessThanOrEqualTo(Double value) {
            addCriterion("promostaccount <=", value, "promostaccount");
            return (Criteria) this;
        }

        public Criteria andPromostaccountIn(List<Double> values) {
            addCriterion("promostaccount in", values, "promostaccount");
            return (Criteria) this;
        }

        public Criteria andPromostaccountNotIn(List<Double> values) {
            addCriterion("promostaccount not in", values, "promostaccount");
            return (Criteria) this;
        }

        public Criteria andPromostaccountBetween(Double value1, Double value2) {
            addCriterion("promostaccount between", value1, value2, "promostaccount");
            return (Criteria) this;
        }

        public Criteria andPromostaccountNotBetween(Double value1, Double value2) {
            addCriterion("promostaccount not between", value1, value2, "promostaccount");
            return (Criteria) this;
        }

        public Criteria andSuccesstimeIsNull() {
            addCriterion("successtime is null");
            return (Criteria) this;
        }

        public Criteria andSuccesstimeIsNotNull() {
            addCriterion("successtime is not null");
            return (Criteria) this;
        }

        public Criteria andSuccesstimeEqualTo(Date value) {
            addCriterion("successtime =", value, "successtime");
            return (Criteria) this;
        }

        public Criteria andSuccesstimeNotEqualTo(Date value) {
            addCriterion("successtime <>", value, "successtime");
            return (Criteria) this;
        }

        public Criteria andSuccesstimeGreaterThan(Date value) {
            addCriterion("successtime >", value, "successtime");
            return (Criteria) this;
        }

        public Criteria andSuccesstimeGreaterThanOrEqualTo(Date value) {
            addCriterion("successtime >=", value, "successtime");
            return (Criteria) this;
        }

        public Criteria andSuccesstimeLessThan(Date value) {
            addCriterion("successtime <", value, "successtime");
            return (Criteria) this;
        }

        public Criteria andSuccesstimeLessThanOrEqualTo(Date value) {
            addCriterion("successtime <=", value, "successtime");
            return (Criteria) this;
        }

        public Criteria andSuccesstimeIn(List<Date> values) {
            addCriterion("successtime in", values, "successtime");
            return (Criteria) this;
        }

        public Criteria andSuccesstimeNotIn(List<Date> values) {
            addCriterion("successtime not in", values, "successtime");
            return (Criteria) this;
        }

        public Criteria andSuccesstimeBetween(Date value1, Date value2) {
            addCriterion("successtime between", value1, value2, "successtime");
            return (Criteria) this;
        }

        public Criteria andSuccesstimeNotBetween(Date value1, Date value2) {
            addCriterion("successtime not between", value1, value2, "successtime");
            return (Criteria) this;
        }

        public Criteria andEndtimeIsNull() {
            addCriterion("endtime is null");
            return (Criteria) this;
        }

        public Criteria andEndtimeIsNotNull() {
            addCriterion("endtime is not null");
            return (Criteria) this;
        }

        public Criteria andEndtimeEqualTo(Date value) {
            addCriterion("endtime =", value, "endtime");
            return (Criteria) this;
        }

        public Criteria andEndtimeNotEqualTo(Date value) {
            addCriterion("endtime <>", value, "endtime");
            return (Criteria) this;
        }

        public Criteria andEndtimeGreaterThan(Date value) {
            addCriterion("endtime >", value, "endtime");
            return (Criteria) this;
        }

        public Criteria andEndtimeGreaterThanOrEqualTo(Date value) {
            addCriterion("endtime >=", value, "endtime");
            return (Criteria) this;
        }

        public Criteria andEndtimeLessThan(Date value) {
            addCriterion("endtime <", value, "endtime");
            return (Criteria) this;
        }

        public Criteria andEndtimeLessThanOrEqualTo(Date value) {
            addCriterion("endtime <=", value, "endtime");
            return (Criteria) this;
        }

        public Criteria andEndtimeIn(List<Date> values) {
            addCriterion("endtime in", values, "endtime");
            return (Criteria) this;
        }

        public Criteria andEndtimeNotIn(List<Date> values) {
            addCriterion("endtime not in", values, "endtime");
            return (Criteria) this;
        }

        public Criteria andEndtimeBetween(Date value1, Date value2) {
            addCriterion("endtime between", value1, value2, "endtime");
            return (Criteria) this;
        }

        public Criteria andEndtimeNotBetween(Date value1, Date value2) {
            addCriterion("endtime not between", value1, value2, "endtime");
            return (Criteria) this;
        }

        public Criteria andOrdernumIsNull() {
            addCriterion("ordernum is null");
            return (Criteria) this;
        }

        public Criteria andOrdernumIsNotNull() {
            addCriterion("ordernum is not null");
            return (Criteria) this;
        }

        public Criteria andOrdernumEqualTo(Integer value) {
            addCriterion("ordernum =", value, "ordernum");
            return (Criteria) this;
        }

        public Criteria andOrdernumNotEqualTo(Integer value) {
            addCriterion("ordernum <>", value, "ordernum");
            return (Criteria) this;
        }

        public Criteria andOrdernumGreaterThan(Integer value) {
            addCriterion("ordernum >", value, "ordernum");
            return (Criteria) this;
        }

        public Criteria andOrdernumGreaterThanOrEqualTo(Integer value) {
            addCriterion("ordernum >=", value, "ordernum");
            return (Criteria) this;
        }

        public Criteria andOrdernumLessThan(Integer value) {
            addCriterion("ordernum <", value, "ordernum");
            return (Criteria) this;
        }

        public Criteria andOrdernumLessThanOrEqualTo(Integer value) {
            addCriterion("ordernum <=", value, "ordernum");
            return (Criteria) this;
        }

        public Criteria andOrdernumIn(List<Integer> values) {
            addCriterion("ordernum in", values, "ordernum");
            return (Criteria) this;
        }

        public Criteria andOrdernumNotIn(List<Integer> values) {
            addCriterion("ordernum not in", values, "ordernum");
            return (Criteria) this;
        }

        public Criteria andOrdernumBetween(Integer value1, Integer value2) {
            addCriterion("ordernum between", value1, value2, "ordernum");
            return (Criteria) this;
        }

        public Criteria andOrdernumNotBetween(Integer value1, Integer value2) {
            addCriterion("ordernum not between", value1, value2, "ordernum");
            return (Criteria) this;
        }

        public Criteria andAutoratioIsNull() {
            addCriterion("autoratio is null");
            return (Criteria) this;
        }

        public Criteria andAutoratioIsNotNull() {
            addCriterion("autoratio is not null");
            return (Criteria) this;
        }

        public Criteria andAutoratioEqualTo(Double value) {
            addCriterion("autoratio =", value, "autoratio");
            return (Criteria) this;
        }

        public Criteria andAutoratioNotEqualTo(Double value) {
            addCriterion("autoratio <>", value, "autoratio");
            return (Criteria) this;
        }

        public Criteria andAutoratioGreaterThan(Double value) {
            addCriterion("autoratio >", value, "autoratio");
            return (Criteria) this;
        }

        public Criteria andAutoratioGreaterThanOrEqualTo(Double value) {
            addCriterion("autoratio >=", value, "autoratio");
            return (Criteria) this;
        }

        public Criteria andAutoratioLessThan(Double value) {
            addCriterion("autoratio <", value, "autoratio");
            return (Criteria) this;
        }

        public Criteria andAutoratioLessThanOrEqualTo(Double value) {
            addCriterion("autoratio <=", value, "autoratio");
            return (Criteria) this;
        }

        public Criteria andAutoratioIn(List<Double> values) {
            addCriterion("autoratio in", values, "autoratio");
            return (Criteria) this;
        }

        public Criteria andAutoratioNotIn(List<Double> values) {
            addCriterion("autoratio not in", values, "autoratio");
            return (Criteria) this;
        }

        public Criteria andAutoratioBetween(Double value1, Double value2) {
            addCriterion("autoratio between", value1, value2, "autoratio");
            return (Criteria) this;
        }

        public Criteria andAutoratioNotBetween(Double value1, Double value2) {
            addCriterion("autoratio not between", value1, value2, "autoratio");
            return (Criteria) this;
        }

        public Criteria andRepaymentIsNull() {
            addCriterion("repayment is null");
            return (Criteria) this;
        }

        public Criteria andRepaymentIsNotNull() {
            addCriterion("repayment is not null");
            return (Criteria) this;
        }

        public Criteria andRepaymentEqualTo(Double value) {
            addCriterion("repayment =", value, "repayment");
            return (Criteria) this;
        }

        public Criteria andRepaymentNotEqualTo(Double value) {
            addCriterion("repayment <>", value, "repayment");
            return (Criteria) this;
        }

        public Criteria andRepaymentGreaterThan(Double value) {
            addCriterion("repayment >", value, "repayment");
            return (Criteria) this;
        }

        public Criteria andRepaymentGreaterThanOrEqualTo(Double value) {
            addCriterion("repayment >=", value, "repayment");
            return (Criteria) this;
        }

        public Criteria andRepaymentLessThan(Double value) {
            addCriterion("repayment <", value, "repayment");
            return (Criteria) this;
        }

        public Criteria andRepaymentLessThanOrEqualTo(Double value) {
            addCriterion("repayment <=", value, "repayment");
            return (Criteria) this;
        }

        public Criteria andRepaymentIn(List<Double> values) {
            addCriterion("repayment in", values, "repayment");
            return (Criteria) this;
        }

        public Criteria andRepaymentNotIn(List<Double> values) {
            addCriterion("repayment not in", values, "repayment");
            return (Criteria) this;
        }

        public Criteria andRepaymentBetween(Double value1, Double value2) {
            addCriterion("repayment between", value1, value2, "repayment");
            return (Criteria) this;
        }

        public Criteria andRepaymentNotBetween(Double value1, Double value2) {
            addCriterion("repayment not between", value1, value2, "repayment");
            return (Criteria) this;
        }

        public Criteria andRepaymentyesIsNull() {
            addCriterion("repaymentyes is null");
            return (Criteria) this;
        }

        public Criteria andRepaymentyesIsNotNull() {
            addCriterion("repaymentyes is not null");
            return (Criteria) this;
        }

        public Criteria andRepaymentyesEqualTo(Double value) {
            addCriterion("repaymentyes =", value, "repaymentyes");
            return (Criteria) this;
        }

        public Criteria andRepaymentyesNotEqualTo(Double value) {
            addCriterion("repaymentyes <>", value, "repaymentyes");
            return (Criteria) this;
        }

        public Criteria andRepaymentyesGreaterThan(Double value) {
            addCriterion("repaymentyes >", value, "repaymentyes");
            return (Criteria) this;
        }

        public Criteria andRepaymentyesGreaterThanOrEqualTo(Double value) {
            addCriterion("repaymentyes >=", value, "repaymentyes");
            return (Criteria) this;
        }

        public Criteria andRepaymentyesLessThan(Double value) {
            addCriterion("repaymentyes <", value, "repaymentyes");
            return (Criteria) this;
        }

        public Criteria andRepaymentyesLessThanOrEqualTo(Double value) {
            addCriterion("repaymentyes <=", value, "repaymentyes");
            return (Criteria) this;
        }

        public Criteria andRepaymentyesIn(List<Double> values) {
            addCriterion("repaymentyes in", values, "repaymentyes");
            return (Criteria) this;
        }

        public Criteria andRepaymentyesNotIn(List<Double> values) {
            addCriterion("repaymentyes not in", values, "repaymentyes");
            return (Criteria) this;
        }

        public Criteria andRepaymentyesBetween(Double value1, Double value2) {
            addCriterion("repaymentyes between", value1, value2, "repaymentyes");
            return (Criteria) this;
        }

        public Criteria andRepaymentyesNotBetween(Double value1, Double value2) {
            addCriterion("repaymentyes not between", value1, value2, "repaymentyes");
            return (Criteria) this;
        }

        public Criteria andExpansionIsNull() {
            addCriterion("expansion is null");
            return (Criteria) this;
        }

        public Criteria andExpansionIsNotNull() {
            addCriterion("expansion is not null");
            return (Criteria) this;
        }

        public Criteria andExpansionEqualTo(String value) {
            addCriterion("expansion =", value, "expansion");
            return (Criteria) this;
        }

        public Criteria andExpansionNotEqualTo(String value) {
            addCriterion("expansion <>", value, "expansion");
            return (Criteria) this;
        }

        public Criteria andExpansionGreaterThan(String value) {
            addCriterion("expansion >", value, "expansion");
            return (Criteria) this;
        }

        public Criteria andExpansionGreaterThanOrEqualTo(String value) {
            addCriterion("expansion >=", value, "expansion");
            return (Criteria) this;
        }

        public Criteria andExpansionLessThan(String value) {
            addCriterion("expansion <", value, "expansion");
            return (Criteria) this;
        }

        public Criteria andExpansionLessThanOrEqualTo(String value) {
            addCriterion("expansion <=", value, "expansion");
            return (Criteria) this;
        }

        public Criteria andExpansionLike(String value) {
            addCriterion("expansion like", value, "expansion");
            return (Criteria) this;
        }

        public Criteria andExpansionNotLike(String value) {
            addCriterion("expansion not like", value, "expansion");
            return (Criteria) this;
        }

        public Criteria andExpansionIn(List<String> values) {
            addCriterion("expansion in", values, "expansion");
            return (Criteria) this;
        }

        public Criteria andExpansionNotIn(List<String> values) {
            addCriterion("expansion not in", values, "expansion");
            return (Criteria) this;
        }

        public Criteria andExpansionBetween(String value1, String value2) {
            addCriterion("expansion between", value1, value2, "expansion");
            return (Criteria) this;
        }

        public Criteria andExpansionNotBetween(String value1, String value2) {
            addCriterion("expansion not between", value1, value2, "expansion");
            return (Criteria) this;
        }

        public Criteria andAddtimeIsNull() {
            addCriterion("addtime is null");
            return (Criteria) this;
        }

        public Criteria andAddtimeIsNotNull() {
            addCriterion("addtime is not null");
            return (Criteria) this;
        }

        public Criteria andAddtimeEqualTo(Date value) {
            addCriterion("addtime =", value, "addtime");
            return (Criteria) this;
        }

        public Criteria andAddtimeNotEqualTo(Date value) {
            addCriterion("addtime <>", value, "addtime");
            return (Criteria) this;
        }

        public Criteria andAddtimeGreaterThan(Date value) {
            addCriterion("addtime >", value, "addtime");
            return (Criteria) this;
        }

        public Criteria andAddtimeGreaterThanOrEqualTo(Date value) {
            addCriterion("addtime >=", value, "addtime");
            return (Criteria) this;
        }

        public Criteria andAddtimeLessThan(Date value) {
            addCriterion("addtime <", value, "addtime");
            return (Criteria) this;
        }

        public Criteria andAddtimeLessThanOrEqualTo(Date value) {
            addCriterion("addtime <=", value, "addtime");
            return (Criteria) this;
        }

        public Criteria andAddtimeIn(List<Date> values) {
            addCriterion("addtime in", values, "addtime");
            return (Criteria) this;
        }

        public Criteria andAddtimeNotIn(List<Date> values) {
            addCriterion("addtime not in", values, "addtime");
            return (Criteria) this;
        }

        public Criteria andAddtimeBetween(Date value1, Date value2) {
            addCriterion("addtime between", value1, value2, "addtime");
            return (Criteria) this;
        }

        public Criteria andAddtimeNotBetween(Date value1, Date value2) {
            addCriterion("addtime not between", value1, value2, "addtime");
            return (Criteria) this;
        }

        public Criteria andAddipIsNull() {
            addCriterion("addip is null");
            return (Criteria) this;
        }

        public Criteria andAddipIsNotNull() {
            addCriterion("addip is not null");
            return (Criteria) this;
        }

        public Criteria andAddipEqualTo(String value) {
            addCriterion("addip =", value, "addip");
            return (Criteria) this;
        }

        public Criteria andAddipNotEqualTo(String value) {
            addCriterion("addip <>", value, "addip");
            return (Criteria) this;
        }

        public Criteria andAddipGreaterThan(String value) {
            addCriterion("addip >", value, "addip");
            return (Criteria) this;
        }

        public Criteria andAddipGreaterThanOrEqualTo(String value) {
            addCriterion("addip >=", value, "addip");
            return (Criteria) this;
        }

        public Criteria andAddipLessThan(String value) {
            addCriterion("addip <", value, "addip");
            return (Criteria) this;
        }

        public Criteria andAddipLessThanOrEqualTo(String value) {
            addCriterion("addip <=", value, "addip");
            return (Criteria) this;
        }

        public Criteria andAddipLike(String value) {
            addCriterion("addip like", value, "addip");
            return (Criteria) this;
        }

        public Criteria andAddipNotLike(String value) {
            addCriterion("addip not like", value, "addip");
            return (Criteria) this;
        }

        public Criteria andAddipIn(List<String> values) {
            addCriterion("addip in", values, "addip");
            return (Criteria) this;
        }

        public Criteria andAddipNotIn(List<String> values) {
            addCriterion("addip not in", values, "addip");
            return (Criteria) this;
        }

        public Criteria andAddipBetween(String value1, String value2) {
            addCriterion("addip between", value1, value2, "addip");
            return (Criteria) this;
        }

        public Criteria andAddipNotBetween(String value1, String value2) {
            addCriterion("addip not between", value1, value2, "addip");
            return (Criteria) this;
        }
    }

    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}